Java中的类与对象

1.类与对象简介：

1.类

a：简介：

是具有相同特性对象的抽象集合，将相同特征的（如：属性），（行为）对象提取出出来，也是一种自定义的数据类型；

比如：人类，就是将所有人的特性提取出来，组成整个人类。

b：基本格式：

class 类名{

属性；：

行为；

}

c：属性和行为：

属性：1.对象的具体特性：比如猫，猫的名字，年龄；-》：！格式：数据类型+属性名：String name；int year；

2.属性可以是基本数据类型也可以是引用数据类型（如：数组，对象，字符串)

行为：对象的具体行为：比如猫，猫可以跑，可以喵喵，可以跳.....这些都是猫的行为，要通过方法实现；

2.对象：

a:简介：

对象是类的具体化，是具体的事物；对象一般由属性和行为构成；

比如：在"人类"中"坤坤"就是一个具体的事物即对象；

2.创建对象两种形式：

//创建对象两种方法：
//1.先声明再创建
//Cat cat;//声明一个对象cat但并没有分配空间，即cat为空
//cat=new Cat();//new一个空间，并赋给cat
//2.直接创建
//Cat cat=new Cat （）；//直接创建一个空间给cat对象//

3.eg：

创建一个数据类型：猫类，将将猫的属性如：name，gender，color，year放进去；
class Cat{
    String name;//名字
    char gender;//性别   //属性可以是类型可以是基本数据类型，也可是引用类型（字符串，数组，对象）
    String color;//颜色  //若属性位赋值，则为默认结果；
    double year;//年龄
}

3.方法

a：简介：

方法(成员方法）:除了属性之外，用于实现对象的行为；

方法在类中创建；！！！

b：方法基本格式：

1：创建方法：public 返回类型方法名（形参列表）{

方法体：用于实现对象的行为；

}

2.调用方法：

先创建对象：类名方法名=new 类名（）；

然后访问：对象.方法（）；

3.方法创建后调用才会被使用！！！

c：方法入门案例：

import java.util.Random;
import java.util.Scanner;
public class method {
    public static void main(String[]ages)
    {
        Scanner myScanner=new Scanner(System.in);
        Person p1=new Person();//创建对象；
        p1.name="坤坤";//访问属性；
        p1.year=250;//
        p1.speak();//方法写好后必须调用才会执行
        //先创建对象，再调用即可；
        System.out.println("name="+p1.name+"\nyear="+p1.year);
        p1.cal01();
        p1.cal02(100);//调用方法，传入形参5到下方的方法；
        int r=p1.getsum(5,6);//调用getsum方法，并传入两个数据；
        System.out.println(r);
    }
}


class Person{//创建类；！
    int year;
    String name;
    public void speak(){//方法快速入门1：eg：利用speak成员方法输出”鸡你太美“；
        //public表示方法无返回值；，void：无返回值;,speak：方法名；,（）：形参
        System.out.println("鸡你太美");//表示方法体
    }
    public void cal01(){//方法快速入门2：添加cal01的方法，实现从1+..100的结果
        int sum=0;
        for(int i=0;i<=100;i++)
        {
            sum+=i;
        }
        System.out.println(sum);
    }
    public void cal02(int n){//添加cal02成员方法，该方法可以接收一个数,计算1+...+n的结果；
        int sum=0;           //int n为形参；！！！！
        for(int i=0;i<=n;i++)
        {
            sum+=i;
        }
        System.out.println(sum);
    }
    public int  getsum(int m,int n)//快速入门4：添加getsum的成员方法，计算两个数的和；
    {                              //用连个形参保存输入的两个数m n值；！！！
        int sum=0;
        sum=sum+m+n;
        return sum;
    }
}

方法使用细节1：.若要返回多个值，使用数组；！！！！
//eg：添加arrar方法实现返回两数之和和两数之差；
/*public class method{
    public static void main(String[]ages)
    {
        Arrar m=new Arrar();
        int res[]=m.arrar(5,8);
        System.out.println("sum="+res[0]);
        System.out.println("cha="+res[1]);
    }
}
class  Arrar{
    public int[]  arrar(int a, int b) {//创建方法：返回类型设为数组
        int m[] = new int[2];
        int sum = a + b;//两数之和
        m[0] = a;//将两数之和装入数组
        int cha = a - b;//两数之差
        m[1] = cha;将两数之差装入数组
        return m;//返回数组；
    }
}

方法使用细节2：跨类中的方法A调用B类方法；需要通过对象名的调用
//exercise1:编写AA类方法：判断一个数是奇数还是偶数，返回boolean
//思路：！！！
//1.方法的返回类型：boolean;
//2.方法名字；
//3.方法形参；输入一个数：n；！！
//4.方法体：判断
public class method{
    public static void main(String[]ages)
    {
        AA pan1=new AA();
        if(pan1.pan(4))//调用方法体；
        {
            System.out.println("是");//如果返回值是true则执行他；
        }else{
            System.out.println("no");//如果返回值为false则执行她；
        }
    }
}
class AA{
    public boolean pan(int n){
        if(n%2==0)//方法体；
        {
            return true;
        }else{
            return false;
        }
    }
}

3.exercise2：根据行，列，字符，打印对应行数和列数的字符
// 比如：行：4，列：4，字符#，则打印相应效果；
//eg:####
//   ####
//   ####
//   ####
//思路:1.行列要用到二维数组,以及for循环；
//考虑这个行为是干什么用的，需要什么：
//2.方法的返回类型：void
//  方法名 print
//  参数列表：1.!!!!!数组的：行长度row，列长度colum；2.输入的字符m；!!!!
//  方法体：循环打印输出图形；

public class method{
    public static void main(String[]ages)
    {
        AA a= new AA();
        a.print(4,4,'*');
    }
}
class AA{
    public void print(int row,int colum,char m){
        for(int i=0;i<row;i++)
        {
            for(int j=0;j<colum;j++)
            {
                System.out.print(m);
            }
            System.out.println();
        }
    }
}

d：方法传参机制练习：

eg1

eg1:使用方法：进行两个数的交换；
//思路：！！！
//返回类型：void
//方法名：swap
//形参：输入的 a，b
//方法体：实现交换；
//1.基本数据类型，传递的是值（值拷贝），形参的任何变化不影响实参！！！
public class MthodParameter0 {
    public static void main(String[]ages)//编写main方法；
    {
        int a=8,b=9;
        AA obj=new AA();
        obj.swap(a,b);//程序走到这会再栈中再开辟一个空间，其与原来的main栈独立！！！；
        //程序之后跳到类中执行swap方法：实现交换，输出的是swap栈·中ab的值，并返回到这里；
        System.out.println("main方法中的a="+a+"b="+b);//输出的是main栈中的a b的值，
        //因为swap栈完成交换后输出，之后就会退出swap方法，swap方法销毁；
        // main栈中的ab值并未发生改变
    }
}
class AA{
    public void swap(int a,int b){
        System.out.println("交换前的a="+a+"交换后的b="+b);
        int swap=0;
        swap=a;
        a=b;  //实现两数交换；
        b=swap;
        System.out.println("交换后的a="+a+"交换后的b="+b);
    }
}

2.引用数据类型(数组，对象)传参机制：传递的是地址（址拷贝）：可以通过形参改变实参！！！！
eg:在B类中编写一个方法test100, 可以接收一个数组，并在该方法中修改该数组，看看原来数组是否变化；
//思路：
//1.方法返回值：void；
//2.名字
//3.参数列表：数组，
//方法体：输出一个数组；
public class MthodParameter0{
    public static void main(String[]ages)
    {
        int arr[]={1,2,3};
        System.out.println("修改之前的数组：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        B b=new B();
        System.out.println("\n修改之后的数组：");
        b.test100(arr);//2.调用方法；
    }
}
class B{
    public void test100(int arr[]){//1.要修改数组，所以必须把数组当作参数传给test200；！！！！
        int i;
        arr[0]=666;//修改arr[0];
        for(i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }

    }
}

eg2

//eg：在B类中编写一个方法test200，可以接收Person(age,sal)对象，在方法中修改对象属性，看看原来对象是否变化；
//!!!!!!修改谁就将他当作所创建方法的参数传过去，然后再调用他；！！！！！！
public class MthodParameter0{
    public static void main(String[]ages)
    {
        Person a=new Person();//创建a对象；
        a.age=5;
        a.sal=666;
        System.out.println("修改前：");
        System.out.println(a.age);
        B b=new B();//创建b对象；
        b.test200(a);//要修改a对象，所以把a对象传过去；！！！！！
        System.out.println("\n修改后：");
        System.out.println(a.age);
    }
}
class Person{
    int age;
    double sal;
}
class B{
    public void test200(Person a){//要修改a对象中的数据，所以要把a对象当作参数传给b对象，再修改；！！！
        a.age=500;//修改；         //Person是自定义的数据类型；+对象名！！
    }
}

eg3:

ex4：编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象；--克隆对象；
//注意：要求得到的对象和原来的对象是两个独立的对象，只是属性相同；
//思路：1.返回类型：/要求得到新对象，所以返回类型应该与person一样，所以为Person类  2.名字：copyPerson
//3.形参：Person，因为要克隆，所以要把Person给他//4.方法体：创建新对象并复制属性并返回即可；！！！！！！！
public class MthodParameter0 {
    public static void main(String[]ages)
    {
        Person p=new Person();
        p.name="坤坤";
        p.kg=250;
        p.year=66;
        System.out.println("p的属性：");
        System.out.println("name="+p.name+"kg="+p.kg+"year="+p.year);
        MyTools tools =new MyTools();//创建tools对象；
        tools.copyPerson(p);//调用copy方法；：进行复制！！！！！
        Person p2= tools.copyPerson(p);//p2用来接收返回的的p2结果到这里！！！
        //到此：p 和p2是Person对象，但他们是连个独立的对象；属性相同；
        System.out.println("\tp2的属性");
        System.out.println("name="+p2.name+"kg="+p2.kg+"year="+p2.year);
    }
}
class Person{
    String name;
    double kg;
    int year;
}
class MyTools{
    public Person copyPerson(Person p){//要求得到新对象，所以返回类型应该与person一样，所以为Person类
        Person p2=new Person();//1.创建一个对象p2；
        p2.name=p.name;
        p2.year=p.year;       //2.复制属性；
        p2.kg=p.kg;
        return p2;            //3.返回p2；
    }
}
 */

4.方法重载：

1.简介：

//一：.重载介绍：
//1.基本介绍：
//java中允许一个类中，多个同名方法的存在，但要求!!!形参列表不一致；！！！

eg：

eg:类：MyCalculator  方法：calculate
//使用相同方法名，求两int和，int double 的和，三个int和
public class OverLoad{
    public static void main(String[]ages){
        MyCalculator sum=new MyCalculator();
        System.out.println(sum.calculate(1,2.8));
        System.out.println(sum.calculate(1,8));
        System.out.println(sum.calculate(1,7,8));

    }
}
class MyCalculator{
    public int calculate(int n1,int n2){//两个int；
        return (n1+n2);
    }
    public double calculate(int n1,double n2){//1int 1double;
        return (n1+n2);
    }
    public int calculate(int n1,int n2,int n3){//3int ;
        return(n1+n2+n3);
    }
}

2.注意细节：

1.前提是：方法名必须一样；！！！
//2.形参列表必须不同（参数的顺序，个数，类型只是有一项不一样）；！！！！
//3.但与参数名无关，返回类型无关（返回类型具体看方法的行为）；

练习：
public class OverLoad{
    public static void main(String[]ages)
    {
        Methods a=new Methods();
        System.out.println(a.m(5));
        System.out.println(a.m(5,8));
        System.out.println(a.m("kunkun"));
        System.out.println(a.max(2.5,5.6));
        System.out.println(a.max(7,6));             //上边的三个调用会自动和下边三个方法匹配；
        System.out.println(a.max(1.1,1.2,1));

    }
}
class Methods {
    public int m(int n) {  //1
        return n * n;
    }
    public int m(int n, int n1) {  //1
        return n * n1;
    }

    public String m(String n) {   //1
        return n;
    }
    public int max(int n1, int n2) {
        if (n1 > n2) {
            return n1;             //2.第一个max重载方法：找两个int最大值
        } else {
            return n2;
        }
    }

eg：2：找三个数中最大值
public double max(double a, double b) {
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }
    public double max(double a, double b, double c) {
        double max1=a>b?a:b;
        return max1>c?max1:c;
    }
}

5.可变参数：

1.简介

/可变参数：
//1.方法名称相同，功能相同，参数个数不同->:可以使用可变参数优化；

eg：

1.int...表示接收的是可变参数，类型是int，即可以接收多个int
2.使用参数时，可以当作数组来使用 即nums可以当作数组；

3.使用参数时，可以当作数组来使用 即nums可以当作数组；
public class Variableparameter {
    public static void main(String[]ages) {
        T a = new T();
        int res=a.sum(4,8,9);
        System.out.println(res);
    }
}
class T{
    public int sum(int...nums){
        int m=0;
        for(int i=0;i<nums.length;i++)
        {
            m+=nums[i];
        }
        return m;
    }
}

2.细节：

/可变参数细节：
//1.可变参数的实参可以为0个或多个；
//2.可变参数的实参可以为数组
//3.可变参数本质就是数组
//4.可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数放在最后；
// 5.一个形参列表只可以出现一个可变参数
//6.属性可以加修饰符，局部变量不能加修饰符；

案例：

public class Variableparameter {
    public static void main(String[]ages){
        HspMethods hm=new HspMethods();
        System.out.println(hm.showscores("kunkun",2.5,2.5));
        System.out.println(hm.showscores("kunkun",2.5,2.5,5.6));
    }
}
class HspMethods{
    //分析：方法名，形参列表（String name，double scores...）,!!!!!!!!返回类型”String‘；倒时候返回Sreing直接拼接返回即可；
    public String showscores(String name,double...scores){
        double sum=0;
        for(int i=0;i<scores.length;i++) {
            sum = sum + scores[i];
        }
        return (name+"有"+ scores.length+"门成绩总分是"+scores);
    }
}

6.作用域：

注意：

1.局部变量和全局变量可以重名,在访问时遵循就近原则！！！！
2.同一个作用域中不可重复定义，比如在同一个方法中‘：变量名不可相同；
3.属性属于全局变量：可以不赋值，有默认值；
  方法中的变量属于局部变量：必须赋值才可使用；
  且只能在本方法中使用；
 4.属性的生命周期较长，伴随着对象的创建而创建，伴随着对象销毁而销毁；
   局部变量生命周期较短，伴随着它的代码块的执行而创建，伴随代码块结束而销毁；//   
 5.作用范围不同：，
   全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
   局部变量：只能在本类中对应的方法中使用；

案例：


//1.局部变量和全局变量可以重名,在访问时遵循就近原则！！！！
public class scope0{
    public static void main(String[]ages){
        T t=new T();
        t.m();
    }
}
class T{
    int age=10;//全局变量；
    public void m(){
        int age=5;//局部变量；
        System.out.println(age);//访问时访问最近的即局部变量所以输出5；
    }

 //2.同一个作用域中不可重复定义，比如在同一个方法中‘：变量名不可相同；
    public void hi(){
        String adress="北京";
        String adress="上海";//(错误：重复定义了)// ；
 }
}

//3.
public class scope0 {
    public static void main(String[]ages)
    {
        Cat m=new Cat();
        m.age=100;
        System.out.println(m.age);
    }
}
class Cat{
    int age=10;//属性属于全局变量：可以赋值，有默认值
    public void cat1(){
        int age=10;//方法中的变量属于局部变量：必须赋值才可使用；
                   //且只能在本方法中使用；
    }
}

5.作用范围不同：，
//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
//局部变量：只能在本类中对应的方法中使用；
/*public class scope0 {
    public static void main(String[]ages){
        M m=new M();
        m.h();
    }
}
class T{
    int age=5;//全局变量；
    public void t1(M t){
        System.out.println()
    }
}
class M{
    public void h(){
        T t=new T();
        System.out.println(t.age);
    }
}
 */
//eg!!!!
/*public class scope0 {
    public static void main (String[]ages){
        T t1=new T();
        t1.test();
    }
}
class T{
    public void test(){
        Person p1=new Person();//创建对象；
        System.out.println(p1.name);//调用对象；
    }
}
class Person{
    String name="jack";
}
 */
//
/*public class scope0 {
    public static void main (String[]ages){
        T1 t1=new T1(); //1.
        t1.test();


        Person p =new Person();  //2.

        t1.test2(p);
    }
}

 */
class Person{
    String name="jack";
}
class T{
    public void test(){  //1.访问jack：创建一个新的方法；
        Person p1=new Person();//创建Person对象；
        System.out.println(p1.name);//调用对象；
    }
    public void test2(Person p ){
        System.out.println(p.name);//2.第二种访问方法：将Person类传过去（跨类访问对象属性方式）
    }
}

Java中类与对象

Java中的类与对象

1.类与对象简介：

1.类

a：简介：

b：基本格式：

c：属性和行为：

2.对象：

a:简介：

2.创建对象两种形式：

3.eg：

3.方法

a：简介：

b：方法基本格式：

c：方法入门案例：

d：方法传参机制练习：

eg1

eg2

eg3:

4.方法重载：

1.简介：

2.注意细节：

5.可变参数：

1.简介

2.细节：

案例：

6.作用域：

注意：

案例：