Mga butangjava nga artikulo

面向对象

面向对象这个对象，指的是客体。所谓客体是指客观存在的对象实体和主观抽象的概念。

为什么要面向对象：

面向对象是为了解决系统的可维护性，可扩展性，可重用性，我们再进一步思考，面向对象为什么能解决系统的可维护性，可扩展性，可重用性？

面向对象产生的历史原因有下面两点：

1、 计算机是帮助人们解决问题的，然而计算机终究是个机器，他只会按照人所写的代码，一步一步的执行下去，最终得到了结果，因此无论程序多么的复杂，计算机总是能轻松应付，结构化编程，就是按照计算机的思维写出的代码，但是人看到这么复杂的逻辑，就无法维护和扩展了。

2、 结构化设计是以功能为目标来设计构造应用系统，这种做法导致我们设计程序时，不得不将客体所构成的现实世界映射到由功能模块组成的解空间中，这种转换过程，背离了人们观察和解决问题的基本思路。

可见结构化设计在设计系统的时候，无法解决重用、维护、扩展的问题，而且会导致逻辑过于复杂，代码晦涩难懂。于是人们就想，能不能让计算机直接模拟现实的环境，用人类解决问题的思路，习惯，步骤来设计相应的应用程序？这样的程序，人们在读它的时候，会更容易理解，也不需要再把现实世界和程序世界之间来回做转换。 

与此同时，人们发现，在现实世界中存在的客体是问题域中的主角，所谓客体是指客观存在的对象实体和主观抽象的概念，这种客体具有属性和行为，而客体是稳定的，行为不稳定的，同时客体之间具有各种联系，因此面向客体编程，比面向行为编程，系统会更稳定，在面对频繁的需求更改时，改变的往往是行为，而客体一般不需要改变，所以我们就把行为封装起来，这样改变时候只需要改变行为即可，主架构则保持了稳定。

于是面向对象就产生了。

类

成员变量

public class OneClass {
    //零到多个成员变量
    public String name;
    protected long num2;
    private int num;
    /*public > protected > private*/
    
    //调用方法
     OneClass one = new OneClass("Lisi", 1212, 151);
}

构造器

public class OneClass {
    //零到多个构造器
    public OneClass(String name, long num, int num2){
        this.name = name;
        this.num = num2;
        this.num2 = num;
    }
}

实例方法

public class OneClass {
    //零到多个类方法
    public String How(String name){
        return "Hello " + name;
    }
    //修饰符 返回值 方法名 (零个或者多个形参)

}

静态变量里面为什么不能调用非静态

==主函数一定是静态方法==

this

  • [x] 在构造器表示调用本类中的构造器
  • [x] 在实例方法中表示调用本类
public class OneClass {
    //零到多个成员变量
    public String name1;
    public String name2;
    public String name3;
    /*public > protected > private*/



    OneClass(String name1) {
        this.name1 = name1 + "abc";
    }

    OneClass(String name1, String name2) {
        this(name1);
        this.name2 = name2;
    }

    OneClass(String name1, String name2, String name3) {
        this(name1, name2);
        this.name3 = name3;
    }
    public void How(){
        this.name3 = "asd";
    }

}

字符串连接符 +

 public static void main(String[] args) {
        //加号
        int i = 6 + 6;
        String name = "Hello " + 2213;
        //加号用在字符串连接时，如果一方为任意基本数据类型，都会被转换成String
 }

变量的命名

以英文字母或者下划线开头，不能以数字开头，也不能跟关键字重合

修饰符

  • [ ] public 可以在项目的任何分包中调用
  • [ ] protect 只能在当前分包中调用
  • [ ] private 只能在当前类或者子类中调用

一、基础

  1. 在一个Java程序中，你总能找到一个类似：
public class Hello {
    ...
}

的定义，这个定义被称为class（类），这里的类名是Hello，大小写敏感，class用来定义一个类，public表示这个类是公开的，public、class都是Java的关键字，必须小写，Hello是类的名字，按照习惯，首字母H要大写。而花括号{}中间则是类的定义。

​ 2. 类的定义中，我们定义了一个名为main的方法：

    public static void main(String[] args) {
        ...
    }

方法是可执行的代码块，一个方法除了方法名main，还有用()括起来的方法参数，这里的main方法有一个参数，参数类型是String[]，参数名是args，public、static用来修饰方法，这里表示它是一个公开的静态方法，void是方法的返回类型，而花括号{}中间的就是方法的代码。

​ 3. Java规定，某个类定义的public static void main(String[] args)是Java程序的固定入口方法，因此，Java程序总是从main方法开始执行。

​ 4. 一个Java源码只能定义一个public类型的class，并且class名称和文件名要完全一致；

​ 使用javac可以将.java源码编译成.class字节码；

​ 使用java可以运行一个已编译的Java程序，参数是类名。

二、从编程中获取的

  1. "\\"是转义字符，输出结果只会是一个"\"
  2.  //"Unicode"也可表示字符型常量
        //用Unicode输出自己的名字
        char c3='\u66f9';
        char c4='\u950b';
        System.out.println(c3);
        System.out.println(c4);
  3. //自动类型转换
        short s=1;
        int i;
        //自动类型转换：short类型转换成int类型（转换后的数据类型的表示范围比转换前的大）
        i=s;
        System.out.println("i="+i);

        //强制类型转换：转换后的数据类型表示的范围比转换前的小
        double d=1.333;
        float f;
        //把double类型的数据强制转换成float类型，要在范围比较大的那个变量前面加（范围小的类型）
        f=(float)d;
  4. "++":    a++表示先做赋值操作，再自增
        ++a表示先自增，后做赋值操作
        "--"一样
  5. “&&”与  前后两个数必须都是true才返回true，否则返回false
“&”不短路与，即执行了(5>3)之后还需执行(4>5)，&&则不用;一般用&&短路，原因：效率高
    
“||”或  只要两个操作数中有一个true就返回true，否则就返回false
“|”不短路或  与不短路与基本一样
    
“！”非  如果操作数为true，返回false；否则返回false
    
“^”异或  当两个操作数不相同时返回true，相同时返回false
    
三目运算符：（表达式）？表达式为true返回值A：表达式为false返回值B；
  6. //定义一个系统输入对象
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();//获取用户输入
  7. //while 是先判断在执行，do...while 是先执行再判断
//while不一定会执行，但是do...while必定会执行一次
  8. //定义一个数组两种方式
        int []arr;
        int arr2[];

//定义一个数组，并且静态初始化
        int arr[]=new int[]{1,2,3};

//定义一个数组，然后动态初始化，长度是3
//int 类型默认全是0
        int arr[]=new int[3];

//二维数组的静态初始化
        int [][]arr=new int[][]{{1,2,3},{4,5,6},{7,8,9}};

//二维数组的动态初始化
        int [][]arr2=new int[3][3];
  9. //定义一个person类的对象zhangsan
        Person zhangsan;
//实例化对象
        zhangsan=new Person();//关键字new
//给对象赋值
        zhangsan.name="张三";
        zhangsan.age=18;
        zhangsan.speak();//调用上面的speak方法
  10. //方法的重载注意点：返回类型不同不能视为方法的重载
        int add(int a, int b){
        System.out.print("方法一:");
        return a+b;
    }

//方法的重载：参数的个数不一样；
        int add(int a,int b,int c){
        System.out.print("方法二:");
        return a+b+c;
    }

//方法的重载：参数的类型不一样
        int add(int a,String b){
        System.out.print("方法三:");
        return a+Integer.parseInt(b);
        //Integer是int对应的类的静态方法，parseInt在这里是把字符串转换成int类型；
  11. Second second=new Second();
//调用普通方法  对象.方法
second.fun1();
//调用静态方法  类名.方法
Second.fun2();
//调用静态方法  对象.方法
second.fun2();
  12. //String属性默认值是null；
//int属性默认值是0；
//默认构造方法，无返回值，其名字与类名一致；

//有参数的构造方法（也可以说是构造方法的重载）初始化
    First(String name2, int age2){
        name = name2;
        age = age2;
        System.out.println("有参数的构造方法");
    }
    
//假如没有构造方法，系统会自动生成一个默认的无参的构造方法，假如有构造方法，系统不会自动生成构造方法；
  13. //this关键字，this表示当前对象，作用1.使用this调用本类中的属性；2.使用this调用构造方法；

this();//如果有参数就在括号内加参数；调用构造方法；
this.name = name;//调用本类中的属性