java都学了点什么？

写在最前面的话

面向对象和面向过程两种编程思想有什么区别？
面向过程是：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。（执行者）
面向对象是：把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。（指挥者）

面向对象设计的三大特性：继承，封装，多态。

类与对象

1.1类和对象的关系：类是对象的抽象，而对象是类的具体实例。类与对象的关系是抽象与类的实例化就是对象，对象的共性特征抽象出来就是类。
（看博主的文章了解到，java中的类和生活中类还是有区别的。钢笔和人是一个类，而人们在生活中却不这样认为）
2.1类的定义格式：【权限修饰符】 classs 类名 【extends 父类名 】 【implemements 接口名】{
}（可以没有【】内的东西）

（访问对象变量：对象引用.变量名或者new 类名（）.对象成员）
必备知识：

2.2对象的创建和使用
默认初始值：

权限修饰符：

类的封装

1.1封装的原因：
为了防止别人随意的修改这些信息，我们将这些信息标记为私人的，也就是私有的，英文表示就是private。
1.2封装的原则：
*将不需要对外提供的内容都隐藏起来，使用private关键字。
*把属性隐藏，提供公共方法对其访问。使用setXXX(), getXXX()方法。

class Cat{
String sex;
//this.sex为成员变量 将传入的sex内容赋值给成员变量
 public void setSex(String sex) { 
                 this.sex = sex;
        }
 
        public String getSex(){
                 return sex;
        }
}

方法的重载和递归

方法的重载

重载的定义：在同一个类中，同名的两个或者是多个方法，参数列表不同，我们称该多个方法为方法重载。

public class Method08 {  
    public static void main(String[] args) {  
        add(1,2);   
    }       
    //计算10和20的和   
    public static void add() {   
        int num1 = 10;     
        int num2 = 20;   
        System.out.println(num1+num2);  
    }   
    //计算传入的两个参数的和  
    public static void add(int num1,int num2){ 
        System.out.println(num1+num2);  
    }        public static void add(int num1){  
        System.out.println(num1+20); 
    }    
    public static void add(int num1,byte num2){
        System.out.println(num1+num2);   
    }       
    public static void add(byte num1,int num2){    
        System.out.println(num1+num2); 
    }
}

*重载在编码过程中是有意义的，针对于不同的参数做相同的功能。
*两同：：同类 同名
*三不同：参数列表不同(个数、类型、顺序)
*方法的方式是：返回值类型+方法名称+参数列表。

方法的递归

递归是一种编程技巧，程序中自己调用自己。在递归程序中重要的问题是：何时出递归程序,在递归程序中存在一个出口–>递归头,递归程序的大优势在于编写时简单。

/计算一个数的阶乘和斐波那契数列
mport java.util.Scanner;
public class recursion {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num =input.nextInt();
        long x = System.currentTimeMillis();
        long a =method(num); // 用递归方法计算一个数的阶乘
        System.out.println("计算的阶乘是："+a);
        long y =System.currentTimeMillis();
        System.out.println("所用的时间是："+(y-x));

        x= System.currentTimeMillis();
        a=method1(num);//用递归计算斐波那契数列
        System.out.println("计算数列的值是："+a);
        y =System.currentTimeMillis();
        System.out.println("所用的时间是："+(y-x));
}
	 // 用递归方法计算一个数的阶乘
    public static int method(int num) {
        if (num==1){
            return 1;
        }
        return method(num-1)*num;
    }
    //用递归计算斐波那契数列
    public  static  int method1(int num){
        if(num==1||num==2){
            return 1;
        }
        return method1(num-1)+method1(num-2);
    }
}

递归虽然简单，但是特别慢！递归程序不光耗时，而且极其吃内存。

构造方法

构造方法是一个特殊的方法。
方法结构：访问修饰符 类名（参数列表）｛方法体｝
构造方法重载。
在没写构造方法是 有一个默认的
类名（）｛｝构造方法
this（）是调用本类不带参构造方法；
super（）是调用父类不带参的构造方法；
第一种：

 public class Student {

 // 成员变量     

private String name;     

private int age;

 public Student(){} //无参构造

 public Student(String name, int age) {      

   this.name = name;       

   this.age = age;     }//有参构造

第二种：

public class A{  
   public A(){  
      System.out.println("调用了无参的构造函数");  
   }  
   public A(String mess){  
      System.out.println("调用了有参的构造函数\n"+  
         "参数内容为："+mess);  
   }  
}  
public class Test{  
   public static void main(String [] args){  
       A a_1=new A();//调用无参的构造函数  
       A a_2=new A("Hello");//调用有参的构造函数  
   }  
}  

super关键字

super主要有两种用法：
一是：调用父类构造方法
二是：调用父类的属性和一般方法
第一种情况：隐式调用父类的无参构造方法
所谓的隐式，就是不将调用过程写出来。也就是说，我什么也不写，程序会默认的去调用父类的. // super();
第二种情况：显式调用

class Child extends Father{
	
	public Child(){				//孩子类无参构造
		super();				//显式调用父类的无参构造，必须写在第一行
		System.out.println("我是子类的无参构造方法");
	}
	
	public Child(String info){	//孩子类带参构造
		super("带参构造方法");				//显式调用父类的带参构造，必须写在第一行
		System.out.println(info);
	}
	
	public void test(){
		
	}
}

this关键字

1.通过 this 关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题

class Person {
	int age;
	public Person(int age) {
		this.age = age;
	}
	public int getAge() {
		return this.age;
	}
}

2.通过 this 关键字调用成员方法。

class Person {
	public void openMouth() {
			// 实现过程
	}
	public void speak() {
		this.openMouth();  // 此处 this 可以省略
	}
}

3.通过 this 调用构造方法
只能在构造方法中，使用 this 调用构造方法，不能在成员方法中使用，该语句必须位于第一行，且只能出现一次

class Person {
	public Person() {
		System.out.println("无参的构造方法被调用了...");
	}
	public Person(String name) {
		this();	// 调用无参的构造方法，必须位于第一行，且只能出现一次
		System.out.println("有参的构造方法被调用了...");
	}
	public class Demo {
		Person person = new Person("itcast");  // 实例化 Person 对象
	}
}

不能在一个类中的两个构造方法中使用 this 互相调用

Class Person{
	public Person(){
		this("小芳");	// 调用有参的构造方法
		System.out.println("无参的构造方法被调用了...");
	}
	public Person(String name) {
		this();	// 调用无参的构造方法
		System.out.println("有参的构造方法被调用了...");
	}
}

static关键字

/测试static
public class Test {
	static int j = 2;// 静态变量 类
	int i = 1;// 成员变量

	public static void main(String args[]) {
		Test.Ace();// 直接调用
		Ace();
		Test A = new Test();
		A.Luffy();// 不能直接调用
		A.Ace();
		Q.q1();// 调用其他类中的静态方法
		Q q = new Q();
		q.q2();// 调用其他类中的成员方法
	}

	// 类方法 静态方法
	static public void Ace() {
		// static int l = 4; 报错
		System.out.println(j);
		Test test = new Test();
		System.out.println(test.i);
	}

	// 成员方法
	public void Luffy() {
		// static int l = 4; 报错
		System.out.println(j);
		System.out.println(i);
	}
}

// 其他类
class Q {
	static void q1() {
	}

	void q2() {
	}
}

如果看到这里的话，还请各位客官点个赞吧！也算是对我一种支持和鼓励吧！